/**
 * 事件总线工具类
 * 提供类型安全的发布订阅功能
 */

import { ITrack } from '@/store/types/track';

// 事件类型定义
export interface EventMap {
    // 轨道相关事件
    'track:added': { trackType: string; trackId?: string };
    'track:updated': { trackId: string };
    'track:deleted': { trackId: string };
    // 草稿相关事件
    'draft:updated': { draftId: string | null };
    // 片段配置更新事件
    'segmentConfig:updated': { 
        draftId: string; 
        trackId: string; 
        segmentId: string; 
        config: any;
    };
    // 可以根据需要扩展更多事件类型
    // 添加轨道并更新UI
    'track:added:ui': any;
}

// 事件监听器类型
type EventListener<T = any> = (data: T) => void;

// 事件监听器映射类型
type EventListeners = {
    [K in keyof EventMap]?: EventListener<EventMap[K]>[];
};

class EventBus {
    private listeners: EventListeners = {};

    /**
     * 订阅事件
     * @param event 事件名称
     * @param listener 事件监听器
     * @returns 取消订阅的函数
     */
    on<K extends keyof EventMap>(event: K, listener: EventListener<EventMap[K]>): () => void {
        if (!this.listeners[event]) {
            this.listeners[event] = [];
        }

        this.listeners[event]!.push(listener);

        // 返回取消订阅的函数
        return () => {
            this.off(event, listener);
        };
    }

    /**
     * 取消订阅事件
     * @param event 事件名称
     * @param listener 事件监听器
     */
    off<K extends keyof EventMap>(event: K, listener: EventListener<EventMap[K]>): void {
        const eventListeners = this.listeners[event];
        if (!eventListeners) return;

        const index = eventListeners.indexOf(listener);
        if (index > -1) {
            eventListeners.splice(index, 1);
        }
    }

    /**
     * 发布事件
     * @param event 事件名称
     * @param data 事件数据
     */
    emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void {
        const eventListeners = this.listeners[event];
        if (!eventListeners) return;

        // 创建监听器副本，避免在执行过程中修改原数组
        const listenersToCall = [...eventListeners];

        listenersToCall.forEach((listener) => {
            try {
                listener(data);
            } catch (error) {
                console.error(`事件监听器执行错误 [${event}]:`, error);
            }
        });
    }

    /**
     * 一次性订阅事件（只触发一次后自动取消订阅）
     * @param event 事件名称
     * @param listener 事件监听器
     * @returns 取消订阅的函数
     */
    once<K extends keyof EventMap>(event: K, listener: EventListener<EventMap[K]>): () => void {
        const onceListener: EventListener<EventMap[K]> = (data) => {
            listener(data);
            this.off(event, onceListener);
        };

        return this.on(event, onceListener);
    }

    /**
     * 清除所有事件监听器
     */
    clear(): void {
        this.listeners = {};
    }

    /**
     * 清除指定事件的所有监听器
     * @param event 事件名称
     */
    clearEvent<K extends keyof EventMap>(event: K): void {
        delete this.listeners[event];
    }

    /**
     * 获取指定事件的监听器数量
     * @param event 事件名称
     * @returns 监听器数量
     */
    getListenerCount<K extends keyof EventMap>(event: K): number {
        return this.listeners[event]?.length || 0;
    }
}

// 创建全局事件总线实例
export const eventBus = new EventBus();

// 导出事件总线类，方便创建独立实例
export { EventBus };

// 默认导出全局实例
export default eventBus;
